import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * Dit is de database die de gebruikers, optredens en commentaren bijhoudt
 * 
 * @author  Eric de Potter
 * @version 1.0
 */
public abstract class Database
{
    public static List<Optreden> OPTREDENS = new ArrayList<Optreden>();
    public static List<Gebruiker> USERS = new ArrayList<Gebruiker>();
    public static List<Commentaar> COMMENTS = new ArrayList<Commentaar>();
    public static Gebruiker CURRENT_USER;
    
    /**
     * Geeft de huidige gebruiker terug.
     * 
     * @return   de huidige gebruiker
     */
    
    public static Gebruiker getCurrentUser()
    {
        return CURRENT_USER;
    }
    
    /**
     * Vervangt de huidige gebruiker met de gegeven gebruiker
     * 
     * @param user de nieuwe huidige gebruiker
     */
    public static void setCurrentUser(Gebruiker user)
    {
        CURRENT_USER = user;
    }
    
    /**
     * Voegt een Optreden-object toe aan de lijst optredens
     * 
     * @param optreden  het optreden-object om toe te voegen
     * @return  true als het toegevoegd is, anders false
     */
    public static boolean addOptreden(Optreden optreden)
    {
        return OPTREDENS.add(optreden);
    }
    
    /**
     * Verwijdert een Optreden-object van de lijst
     * 
     * @param optreden  het optreden-object dat verwijdert moet worden
     * @return  true als het verwijdert is, anders false
     */
    public static boolean removeOptreden(Optreden optreden)
    {
        return OPTREDENS.remove(optreden);
    }
    
    /**
     * @return  de huidige lijst van alle optredens
     */
    public static List<Optreden> getOptredens()
    {
        return OPTREDENS;
    }
    
    /**
     * Vervangt de huidige lijst met de gegeven lijst
     * 
     * @param nieuwe de nieuwe lijst
     */
    public static void replaceOptredens(List<Optreden> nieuwe)
    {
        OPTREDENS.clear();
        OPTREDENS.addAll(nieuwe);
    }
    
    /**
     * Voegt een Gebruiker-object toe aan de lijst gebruikers
     * 
     * @param user  het gebuiker-object om toe te voegen
     * @return  true als het toegevoegd is, anders false
     */
    public static boolean addUser(Gebruiker user)
    {
        return USERS.add(user);
    }
    
    /**
     * Verwijdert een Gebruiker-object van de lijst
     * 
     * @param user  het gebruiker-object dat verwijdert moet worden
     * @return  true als het verwijdert is, anders false
     */
    public static boolean removeUser(Gebruiker user)
    {
        return USERS.remove(user);
    }
    
    /**
     * @return  de huidige lijst van alle gebruikers
     */
    public static List<Gebruiker> getUsers()
    {
        return USERS;
    }

    /**
     * Vervangt de huidige lijst met de gegeven lijst
     * 
     * @param nieuwe de nieuwe lijst
     */
    public static void replaceUsers(List<Gebruiker> nieuwe)
    {
        USERS.clear();
        USERS.addAll(nieuwe);
    }
    
    /**
     * Voegt een Commentaar-object toe aan de lijst comments
     * 
     * @param comment  het commentaar-object om toe te voegen
     * @return  true als het toegevoegd is, anders false
     */
    public static boolean addComment(Commentaar comment)
    {
        return COMMENTS.add(comment);
    }
    
    /**
     * Verwijdert een Commentaar-object van de lijst
     * 
     * @param comment  het Commentaar-object dat verwijdert moet worden
     * @return  true als het verwijdert is, anders false
     */
    public static boolean removeComment(Commentaar comment)
    {
        return COMMENTS.remove(comment);
    }
    
    /**
     * @return  de huidige lijst van alle commentaren
     */
    public static List<Commentaar> getComments()
    {
        return COMMENTS;
    }
    
    /**
     * Vervangt de huidige lijst met de gegeven lijst
     * 
     * @param nieuwe de nieuwe lijst
     */
    public static void replaceComments(List<Commentaar> nieuwe)
    {
        COMMENTS.clear();
        COMMENTS.addAll(nieuwe);
    }
    
    /**
     * Verwijdert alles in de database
     */
    public static void clearDatabase()
    {
        OPTREDENS.clear();
        USERS.clear();
        COMMENTS.clear();
        CURRENT_USER = null;
    }
    
    /**
     * @param optreden het optreden waarvan men het aantal bezoekers wil weten 
     * @return  het aantal bezoekers van het optreden
     */
    public static int getNumberAttendants(Optreden optreden)
    {
        int numberAttendants = 0;
        List<Gebruiker> users = USERS;
        for (Gebruiker user : users) {
            List<Optreden> optredens = user.getOptredens();
            if (optredens.contains(optreden))
                numberAttendants++;
            else {
                for (Optreden user_optreden : optredens) {
                    if (user_optreden.toString().equals(optreden.toString())) {
                        numberAttendants++;
                    }
                }
            }
        }
        return numberAttendants;
    }  
    
    /**
     * @param optreden het optreden waarvan men het aantal commentaren wil weten
     * @return het aantal commentaren dat het optreden heeft gekregen
     */
    public static int getNumberComments(Optreden optreden)
    {
        int numberComments = 0;
        Commentaar comment;
        Iterator<Commentaar> it = COMMENTS.iterator();
        while (it.hasNext()) {
            comment = it.next();
            if (comment.getOptreden().equals(optreden))
                numberComments++;
            else if (comment.getOptreden().toString().equals(optreden.toString()))
                numberComments++;
        }
        return numberComments;
    }
    
    /**
     * @param optreden het optreden waar men de commentare van wil hebbe
     * @return alle commentaren die bij dit optreden horen
     */
    public static List<Commentaar> getComments(Optreden optreden)
    {
        List<Commentaar> allComments = COMMENTS;
        List<Commentaar> returnComments = new ArrayList<Commentaar>();
        for (Commentaar comment: allComments) {
            if (comment.getOptreden().equals(optreden))
                returnComments.add(comment);
            else if (comment.getOptreden().toString().equals(optreden.toString()))
                returnComments.add(comment);
        }
        return returnComments;
    }
    
    /**
     * Zoekt de commentaren van deze gebruiker
     * 
     * @return  een lijst van alle commentaren van deze gebruiker
     */
    public static List<Commentaar> getComments(Gebruiker gebruiker)
    {
        List<Commentaar> comments = COMMENTS;
        List<Commentaar> userComments = new ArrayList<Commentaar>();
        for (Commentaar comment : comments) {
            if (comment.getUser().equals(gebruiker)) 
                userComments.add(comment);
            else if (comment.getUser().getName().equals(gebruiker.getName())) 
                userComments.add(comment);
        }
        return userComments;
    }
}
